#include <iostream>
#include <string>
#include <vector>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>
#include <cstring>

// 创建多线程
const int num = 10;

void* routine(void* args)
{
    sleep(1);
    std::string name = static_cast<const char*>(args);
    delete (char*)args;
    std::cout << "I am new thread, my name is " << name << std::endl;

    return nullptr;
}

int main()
{
    char id[64];
    std::vector<pthread_t> tids;
    // 循环创建线程
    for (int i = 0; i < num; i++)
    {
        pthread_t tid;
        // 这里需要给没一个线程的线程名字(id)分配一块区域，如果在栈上开辟空间，上一个线程
        // 创建使用完之后，下一个线程在创建的时候可能会复用id的地址空间，而传给线程的是指向空间的指针
        // 这就会导致所有创建的线程给的指针指向同一块空间
        // char id[64];
        char* id = new char[64];
        snprintf(id, 64, "thread-%d", i);
        int n = pthread_create(&tid, nullptr, routine, id);
        if (n == 0)
        {
            tids.push_back(tid);
        }
        else
            continue;
    }

    for (int i = 0; i < num; i++)
    {
        //一个一个等待回收
        int n = pthread_join(tids[i], nullptr);
        if (n == 0)
        {
            std::cout << "pthread_join success" << std::endl;
        }
    }
    return 0;
}

// void* routine(void* args)
// {
//     // 新线程自己分离自己
//     pthread_detach(pthread_self());
//     std::cout << "new thread is detached" << std::endl;
//     std::string name = static_cast<const char*>(args);
//     int cnt = 5;
//     while(cnt--)
//     {
//         sleep(1);
//         std::cout << "I am new thread, my name is " << name << std::endl;
//     }

//     return nullptr;
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, routine, (void*)"thread-1");

//     //主线程分离新线程
//     // pthread_detach(tid);
//     // std::cout << "new thread is detached" << std::endl;

//     int cnt = 5;
//     while(cnt--)
//     {
//         std::cout << "I am major thread" << std::endl;
//         sleep(1);
//     }

//     int n = pthread_join(tid, nullptr);
//     if (n != 0)
//     {
//         std::cout << "pthread_join error: " << strerror(n) << std::endl;
//     }
//     else
//     {
//         std::cout << "pthread_join success " << std::endl;
//     }
//     return 0;
// }

// class Task
// {
// public:
//     Task(int a, int b)
//         : _a(a), _b(b)
//     {}

//     int Execute()
//     {
//         return _a + _b;
//     }

//     ~Task() {}
// private:
//     int _a;
//     int _b;
// };

// class Result
// {
// public:
//     Result(int result)
//         : _result(result)
//         {}

//     int GetResult()
//     {
//         return _result;
//     }
//     ~Result() {}
// private:
//     int _result;
// };

// void* routine(void* args)
// {
//     Task* t = static_cast<Task*>(args);
//     sleep(1);
//     Result* res = new Result(t->Execute());
//     sleep(1);
//     // return res;
//     pthread_exit(res);
// }

// int main()
// {
//     pthread_t tid;
//     Task* t = new Task(20, 30);
//     pthread_create(&tid, nullptr, routine, t);

//     Result* res = nullptr;
//     pthread_join(tid, (void**)&res);
//     int n = res->GetResult();
//     std::cout << "running over, the result is " << n << std::endl;

//     delete t;
//     delete res;
//     return 0;
// }

// void *routine(void *args)
// {
//     std::string name = static_cast<const char *>(args);
//     int cnt = 10;
//     while (cnt--)
//     {
//         sleep(1);
//         std::cout << "I am new thread, my name is " << name << std::endl;
//     }

//     return (void *)10;
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, routine, (void *)"thread-1");

//     // 主线程
//     int cnt = 5;
//     while (cnt--)
//     {
//         std::cout << "I am major thread" << std::endl;
//         sleep(1);
//     }

//     // 新线程结束
//     void *ret = nullptr;
//     pthread_join(tid, &ret);

//     std::cout << "new thread over and exit number is " << (long long)ret << std::endl;
//     return 0;
// }